home *** CD-ROM | disk | FTP | other *** search
/ CU Amiga Super CD-ROM 14 / CU Amiga Magazine's Super CD-ROM 14 (1997)(EMAP Images)(GB)(Track 1 of 3)[!][issue 1997-09].iso / CUCD / Programming / Mesa-2.2 / src / api1.c < prev    next >
Encoding:
C/C++ Source or Header  |  1997-06-25  |  31.9 KB  |  1,599 lines
  1. /* $Id: api.c,v 1.4 1996/09/27 01:23:50 brianp Exp $ */
  2.  
  3. /*
  4.  * Mesa 3-D graphics library
  5.  * Version:  2.0
  6.  * Copyright (C) 1995-1996  Brian Paul
  7.  *
  8.  * This library is free software; you can redistribute it and/or
  9.  * modify it under the terms of the GNU Library General Public
  10.  * License as published by the Free Software Foundation; either
  11.  * version 2 of the License, or (at your option) any later version.
  12.  *
  13.  * This library is distributed in the hope that it will be useful,
  14.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16.  * Library General Public License for more details.
  17.  *
  18.  * You should have received a copy of the GNU Library General Public
  19.  * License along with this library; if not, write to the Free
  20.  * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  21.  */
  22.  
  23.  
  24. /*
  25.  * $Log: api.c,v $
  26.  * Revision 1.4  1996/09/27 01:23:50  brianp
  27.  * added extra error checking when DEBUG is defined
  28.  *
  29.  * Revision 1.3  1996/09/26 22:52:12  brianp
  30.  * added glInterleavedArrays
  31.  *
  32.  * Revision 1.2  1996/09/14 06:27:22  brianp
  33.  * some functions didn't return needed values
  34.  *
  35.  * Revision 1.1  1996/09/13 01:38:16  brianp
  36.  * Initial revision
  37.  *
  38.  */
  39.  
  40. #include <stdlib.h>
  41. #include <stdio.h>
  42. #include "bitmap.h"
  43. #include "context.h"
  44. #include "eval.h"
  45. #include "image.h"
  46. #include "macros.h"
  47. #include "matrix.h"
  48. #include "teximage.h"
  49. #include "types.h"
  50.  
  51.  
  52.  
  53. #ifdef MULTI_THREADING
  54.  
  55. /* Get the context associated with the calling thread */
  56. #define GET_CONTEXT    GLcontext* ctx = gl_get_thread_context()
  57.  
  58. #else
  59.  
  60. #ifdef DEBUG
  61. #define GET_CONTEXT                            \
  62.     printf("GL Command executed 1:%s\n",__FUNC__);    \
  63.     if (!CC) {                                    \
  64.        fprintf(stderr,"Mesa error:  no rendering context!\n");    \
  65.        abort();                                    \
  66.     }
  67.  
  68. #else
  69. /* CC is a global pointer for all threads in the address space */
  70. #define GET_CONTEXT
  71. #endif /*DEBUG*/
  72.  
  73. #endif /*MULTI_THREADED*/
  74.  
  75.  
  76.  
  77. #define SHORTCUT
  78.  
  79.  
  80. void glAccum( GLenum op, GLfloat value )
  81. {
  82.    GET_CONTEXT;
  83.    (*CC->API.Accum)(CC, op, value);
  84. }
  85.  
  86.  
  87. void glAlphaFunc( GLenum func, GLclampf ref )
  88. {
  89.    GET_CONTEXT;
  90.    (*CC->API.AlphaFunc)(CC, func, ref);
  91. }
  92.  
  93.  
  94. GLboolean glAreTexturesResident( GLsizei n, const GLuint *textures,
  95.                                  GLboolean *residences )
  96. {
  97.    GET_CONTEXT;
  98.    return (*CC->API.AreTexturesResident)(CC, n, textures, residences);
  99. }
  100.  
  101.  
  102. void glArrayElement( GLint i )
  103. {
  104.    GET_CONTEXT;
  105.    (*CC->API.ArrayElement)(CC, i);
  106. }
  107.  
  108.  
  109. void glBegin( GLenum mode )
  110. {
  111.    GET_CONTEXT;
  112.    (*CC->API.Begin)( CC, mode );
  113. }
  114.  
  115.  
  116. void glBindTexture( GLenum target, GLuint texture )
  117. {
  118.    GET_CONTEXT;
  119.    (*CC->API.BindTexture)(CC, target, texture);
  120. }
  121.  
  122.  
  123. void glBitmap( GLsizei width, GLsizei height,
  124.                GLfloat xorig, GLfloat yorig,
  125.                GLfloat xmove, GLfloat ymove,
  126.                const GLubyte *bitmap )
  127. {
  128.    GET_CONTEXT;
  129.    if (!CC->CompileFlag) {
  130.       /* execute only, try optimized case where no unpacking needed */
  131.       if (   CC->Unpack.LsbFirst==GL_FALSE
  132.           && CC->Unpack.Alignment==1
  133.           && CC->Unpack.RowLength==0
  134.           && CC->Unpack.SkipPixels==0
  135.           && CC->Unpack.SkipRows==0) {
  136.          /* Special case: no unpacking needed */
  137.          struct gl_image image;
  138.          image.Width = width;
  139.          image.Height = height;
  140.          image.Components = 0;
  141.          image.Type = GL_BITMAP;
  142.          image.Data = (GLvoid *) bitmap;
  143.          (*CC->Exec.Bitmap)( CC, width, height, xorig, yorig,
  144.                              xmove, ymove, &image );
  145.       }
  146.       else {
  147.          struct gl_image *image;
  148.          image = gl_unpack_bitmap( CC, width, height, bitmap );
  149.          (*CC->Exec.Bitmap)( CC, width, height, xorig, yorig,
  150.                              xmove, ymove, image );
  151.          gl_free_image( image );
  152.       }
  153.    }
  154.    else {
  155.       /* compile and maybe execute */
  156.       struct gl_image *image;
  157.       image = gl_unpack_bitmap( CC, width, height, bitmap );
  158.       (*CC->API.Bitmap)(CC, width, height, xorig, yorig, xmove, ymove, image );
  159.    }
  160. }
  161.  
  162.  
  163. void glBlendFunc( GLenum sfactor, GLenum dfactor )
  164. {
  165.    GET_CONTEXT;
  166.    (*CC->API.BlendFunc)(CC, sfactor, dfactor);
  167. }
  168.  
  169.  
  170. void glCallList( GLuint list )
  171. {
  172.    GET_CONTEXT;
  173.    (*CC->API.CallList)(CC, list);
  174. }
  175.  
  176.  
  177. void glCallLists( GLsizei n, GLenum type, const GLvoid *lists )
  178. {
  179.    GET_CONTEXT;
  180.    (*CC->API.CallLists)(CC, n, type, lists);
  181. }
  182.  
  183.  
  184. void glClear( GLbitfield mask )
  185. {
  186.    GET_CONTEXT;
  187.    (*CC->API.Clear)(CC, mask);
  188. }
  189.  
  190.  
  191. void glClearAccum( GLfloat red, GLfloat green,
  192.               GLfloat blue, GLfloat alpha )
  193. {
  194.    GET_CONTEXT;
  195.    (*CC->API.ClearAccum)(CC, red, green, blue, alpha);
  196. }
  197.  
  198.  
  199.  
  200. void glClearIndex( GLfloat c )
  201. {
  202.    GET_CONTEXT;
  203.    (*CC->API.ClearIndex)(CC, c);
  204. }
  205.  
  206.  
  207. void glClearColor( GLclampf red,
  208.               GLclampf green,
  209.               GLclampf blue,
  210.               GLclampf alpha )
  211. {
  212.    GET_CONTEXT;
  213.    (*CC->API.ClearColor)(CC, red, green, blue, alpha);
  214. }
  215.  
  216.  
  217. void glClearDepth( GLclampd depth )
  218. {
  219.    GET_CONTEXT;
  220.    (*CC->API.ClearDepth)( CC, depth );
  221. }
  222.  
  223.  
  224. void glClearStencil( GLint s )
  225. {
  226.    GET_CONTEXT;
  227.    (*CC->API.ClearStencil)(CC, s);
  228. }
  229.  
  230.  
  231. void glClipPlane( GLenum plane, const GLdouble *equation )
  232. {
  233.    GLfloat eq[4];
  234.    GET_CONTEXT;
  235.    eq[0] = (GLfloat) equation[0];
  236.    eq[1] = (GLfloat) equation[1];
  237.    eq[2] = (GLfloat) equation[2];
  238.    eq[3] = (GLfloat) equation[3];
  239.    (*CC->API.ClipPlane)(CC, plane, eq );
  240. }
  241.  
  242.  
  243. void glColor3b( GLbyte red, GLbyte green, GLbyte blue )
  244. {
  245.    GET_CONTEXT;
  246.    (*CC->API.Color4f)( CC, BYTE_TO_FLOAT(red), BYTE_TO_FLOAT(green),
  247.                            BYTE_TO_FLOAT(blue), 1.0F );
  248. }
  249.  
  250.  
  251. void glColor3d( GLdouble red, GLdouble green, GLdouble blue )
  252. {
  253.    GET_CONTEXT;
  254.    (*CC->API.Color4f)( CC, (GLfloat) red, (GLfloat) green,
  255.                            (GLfloat) blue, 1.0F );
  256. }
  257.  
  258.  
  259. void glColor3f( GLfloat red, GLfloat green, GLfloat blue )
  260. {
  261.    GET_CONTEXT;
  262.    (*CC->API.Color4f)( CC, red, green, blue, 1.0F );
  263. }
  264.  
  265.  
  266. void glColor3i( GLint red, GLint green, GLint blue )
  267. {
  268.    GET_CONTEXT;
  269.    (*CC->API.Color4f)( CC, INT_TO_FLOAT(red), INT_TO_FLOAT(green),
  270.                            INT_TO_FLOAT(blue), 1.0F );
  271. }
  272.  
  273.  
  274. void glColor3s( GLshort red, GLshort green, GLshort blue )
  275. {
  276.    GET_CONTEXT;
  277.    (*CC->API.Color4f)( CC, SHORT_TO_FLOAT(red), SHORT_TO_FLOAT(green),
  278.                            SHORT_TO_FLOAT(blue), 1.0F );
  279. }
  280.  
  281.  
  282. void glColor3ub( GLubyte red, GLubyte green, GLubyte blue )
  283. {
  284.    GET_CONTEXT;
  285.    (*CC->API.Color4ub)( CC, red, green, blue, 255 );
  286. }
  287.  
  288.  
  289. void glColor3ui( GLuint red, GLuint green, GLuint blue )
  290. {
  291.    GET_CONTEXT;
  292.    (*CC->API.Color4f)( CC, UINT_TO_FLOAT(red), UINT_TO_FLOAT(green),
  293.                            UINT_TO_FLOAT(blue), 1.0F );
  294. }
  295.  
  296.  
  297. void glColor3us( GLushort red, GLushort green, GLushort blue )
  298. {
  299.    GET_CONTEXT;
  300.    (*CC->API.Color4f)( CC, USHORT_TO_FLOAT(red), USHORT_TO_FLOAT(green),
  301.                            USHORT_TO_FLOAT(blue), 1.0F );
  302. }
  303.  
  304.  
  305. void glColor4b( GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha )
  306. {
  307.    GET_CONTEXT;
  308.    (*CC->API.Color4f)( CC, BYTE_TO_FLOAT(red), BYTE_TO_FLOAT(green),
  309.                            BYTE_TO_FLOAT(blue), BYTE_TO_FLOAT(alpha) );
  310. }
  311.  
  312.  
  313. void glColor4d( GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha )
  314. {
  315.    GET_CONTEXT;
  316.    (*CC->API.Color4f)( CC, (GLfloat) red, (GLfloat) green,
  317.                            (GLfloat) blue, (GLfloat) alpha );
  318. }
  319.  
  320.  
  321. void glColor4f( GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha )
  322. {
  323.    GET_CONTEXT;
  324.    (*CC->API.Color4f)( CC, red, green, blue, alpha );
  325. }
  326.  
  327. void glColor4i( GLint red, GLint green, GLint blue, GLint alpha )
  328. {
  329.    GET_CONTEXT;
  330.    (*CC->API.Color4f)( CC, INT_TO_FLOAT(red), INT_TO_FLOAT(green),
  331.                            INT_TO_FLOAT(blue), INT_TO_FLOAT(alpha) );
  332. }
  333.  
  334.  
  335. void glColor4s( GLshort red, GLshort green, GLshort blue, GLshort alpha )
  336. {
  337.    GET_CONTEXT;
  338.    (*CC->API.Color4f)( CC, SHORT_TO_FLOAT(red), SHORT_TO_FLOAT(green),
  339.                            SHORT_TO_FLOAT(blue), SHORT_TO_FLOAT(alpha) );
  340. }
  341.  
  342. void glColor4ub( GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha )
  343. {
  344.    GET_CONTEXT;
  345.    (*CC->API.Color4ub)( CC, red, green, blue, alpha );
  346. }
  347.  
  348. void glColor4ui( GLuint red, GLuint green, GLuint blue, GLuint alpha )
  349. {
  350.    GET_CONTEXT;
  351.    (*CC->API.Color4f)( CC, UINT_TO_FLOAT(red), UINT_TO_FLOAT(green),
  352.                            UINT_TO_FLOAT(blue), UINT_TO_FLOAT(alpha) );
  353. }
  354.  
  355. void glColor4us( GLushort red, GLushort green, GLushort blue, GLushort alpha )
  356. {
  357.    GET_CONTEXT;
  358.    (*CC->API.Color4f)( CC, USHORT_TO_FLOAT(red), USHORT_TO_FLOAT(green),
  359.                            USHORT_TO_FLOAT(blue), USHORT_TO_FLOAT(alpha) );
  360. }
  361.  
  362.  
  363. void glColor3bv( const GLbyte *v )
  364. {
  365.    GET_CONTEXT;
  366.    (*CC->API.Color4f)( CC, BYTE_TO_FLOAT(v[0]), BYTE_TO_FLOAT(v[1]),
  367.                            BYTE_TO_FLOAT(v[2]), 1.0F );
  368. }
  369.  
  370.  
  371. void glColor3dv( const GLdouble *v )
  372. {
  373.    GET_CONTEXT;
  374.    (*CC->API.Color4f)( CC, (GLdouble) v[0], (GLdouble) v[1],
  375.                            (GLdouble) v[2], 1.0F );
  376. }
  377.  
  378.  
  379. void glColor3fv( const GLfloat *v )
  380. {
  381.    GET_CONTEXT;
  382.    (*CC->API.Color4f)( CC, v[0],v [1], v[2], 1.0F );
  383. }
  384.  
  385.  
  386. void glColor3iv( const GLint *v )
  387. {
  388.    GET_CONTEXT;
  389.    (*CC->API.Color4f)( CC, INT_TO_FLOAT(v[0]), INT_TO_FLOAT(v[1]),
  390.                            INT_TO_FLOAT(v[2]), 1.0F );
  391. }
  392.  
  393.  
  394. void glColor3sv( const GLshort *v )
  395. {
  396.    GET_CONTEXT;
  397.    (*CC->API.Color4f)( CC, SHORT_TO_FLOAT(v[0]), SHORT_TO_FLOAT(v[1]),
  398.                            SHORT_TO_FLOAT(v[2]), 1.0F );
  399. }
  400.  
  401.  
  402. void glColor3ubv( const GLubyte *v )
  403. {
  404.    GET_CONTEXT;
  405.    (*CC->API.Color4ub)( CC, v[0], v[1], v[2], 255 );
  406. }
  407.  
  408.  
  409. void glColor3uiv( const GLuint *v )
  410. {
  411.    GET_CONTEXT;
  412.    (*CC->API.Color4f)( CC, UINT_TO_FLOAT(v[0]), UINT_TO_FLOAT(v[1]),
  413.                            UINT_TO_FLOAT(v[2]), 1.0F );
  414. }
  415.  
  416.  
  417. void glColor3usv( const GLushort *v )
  418. {
  419.    GET_CONTEXT;
  420.    (*CC->API.Color4f)( CC, USHORT_TO_FLOAT(v[0]), USHORT_TO_FLOAT(v[1]),
  421.                            USHORT_TO_FLOAT(v[2]), 1.0F );
  422.  
  423. }
  424.  
  425.  
  426. void glColor4bv( const GLbyte *v )
  427. {
  428.    GET_CONTEXT;
  429.    (*CC->API.Color4f)( CC, BYTE_TO_FLOAT(v[0]), BYTE_TO_FLOAT(v[1]),
  430.                            BYTE_TO_FLOAT(v[2]), BYTE_TO_FLOAT(v[3]) );
  431. }
  432.  
  433.  
  434. void glColor4dv( const GLdouble *v )
  435. {
  436.    GET_CONTEXT;
  437.    (*CC->API.Color4f)( CC, (GLdouble) v[0], (GLdouble) v[1],
  438.                            (GLdouble) v[2], (GLdouble) v[3] );
  439. }
  440.  
  441.  
  442. void glColor4fv( const GLfloat *v )
  443. {
  444.    GET_CONTEXT;
  445.    (*CC->API.Color4f)( CC, v[0], v[1], v[2], v[3] );
  446. }
  447.  
  448.  
  449. void glColor4iv( const GLint *v )
  450. {
  451.    GET_CONTEXT;
  452.    (*CC->API.Color4f)( CC, INT_TO_FLOAT(v[0]), INT_TO_FLOAT(v[1]),
  453.                            INT_TO_FLOAT(v[2]), INT_TO_FLOAT(v[3]) );
  454. }
  455.  
  456.  
  457. void glColor4sv( const GLshort *v )
  458. {
  459.    GET_CONTEXT;
  460.    (*CC->API.Color4f)( CC, SHORT_TO_FLOAT(v[0]), SHORT_TO_FLOAT(v[1]),
  461.                            SHORT_TO_FLOAT(v[2]), SHORT_TO_FLOAT(v[3]) );
  462. }
  463.  
  464.  
  465. void glColor4ubv( const GLubyte *v )
  466. {
  467.    GET_CONTEXT;
  468.    (*CC->API.Color4ub)( CC, v[0], v[1], v[2], v[3] );
  469. }
  470.  
  471.  
  472. void glColor4uiv( const GLuint *v )
  473. {
  474.    GET_CONTEXT;
  475.    (*CC->API.Color4f)( CC, UINT_TO_FLOAT(v[0]), UINT_TO_FLOAT(v[1]),
  476.                            UINT_TO_FLOAT(v[2]), UINT_TO_FLOAT(v[3]) );
  477. }
  478.  
  479.  
  480. void glColor4usv( const GLushort *v )
  481. {
  482.    GET_CONTEXT;
  483.    (*CC->API.Color4f)( CC, USHORT_TO_FLOAT(v[0]), USHORT_TO_FLOAT(v[1]),
  484.                            USHORT_TO_FLOAT(v[2]), USHORT_TO_FLOAT(v[3]) );
  485. }
  486.  
  487.  
  488. void glColorMask( GLboolean red, GLboolean green,
  489.              GLboolean blue, GLboolean alpha )
  490. {
  491.     GET_CONTEXT;
  492.     (*CC->API.ColorMask)(CC, red, green, blue, alpha);
  493. }
  494.  
  495.  
  496. void glColorMaterial( GLenum face, GLenum mode )
  497. {
  498.     GET_CONTEXT;
  499.     (*CC->API.ColorMaterial)(CC, face, mode);
  500. }
  501.  
  502.  
  503. void glColorPointer( GLint size, GLenum type, GLsizei stride,
  504.                      const GLvoid *ptr )
  505. {
  506.     GET_CONTEXT;
  507.     (*CC->API.ColorPointer)(CC, size, type, stride, ptr);
  508. }
  509.  
  510.  
  511. void glCopyPixels( GLint x, GLint y, GLsizei width, GLsizei height,
  512.               GLenum type )
  513. {
  514.     GET_CONTEXT;
  515.     (*CC->API.CopyPixels)(CC, x, y, width, height, type);
  516. }
  517.  
  518.  
  519. void glCopyTexImage1D( GLenum target, GLint level,
  520.                        GLenum internalformat,
  521.                        GLint x, GLint y,
  522.                        GLsizei width, GLint border )
  523. {
  524.    GET_CONTEXT;
  525.    (*CC->API.CopyTexImage1D)( CC, target, level, internalformat,
  526.                                  x, y, width, border );
  527. }
  528.  
  529.  
  530. void glCopyTexImage2D( GLenum target, GLint level,
  531.                        GLenum internalformat,
  532.                        GLint x, GLint y,
  533.                        GLsizei width, GLsizei height, GLint border )
  534. {
  535.    GET_CONTEXT;
  536.    (*CC->API.CopyTexImage2D)( CC, target, level, internalformat,
  537.                               x, y, width, height, border );
  538. }
  539.  
  540.  
  541. void glCopyTexSubImage1D( GLenum target, GLint level,
  542.                           GLint xoffset, GLint x, GLint y,
  543.                           GLsizei width )
  544. {
  545.    GET_CONTEXT;
  546.    (*CC->API.CopyTexSubImage1D)( CC, target, level, xoffset, x, y, width );
  547. }
  548.  
  549.  
  550. void glCopyTexSubImage2D( GLenum target, GLint level,
  551.                           GLint xoffset, GLint yoffset,
  552.                           GLint x, GLint y,
  553.                           GLsizei width, GLsizei height )
  554. {
  555.    GET_CONTEXT;
  556.    (*CC->API.CopyTexSubImage2D)( CC, target, level, xoffset, yoffset,
  557.                                  x, y, width, height );
  558. }
  559.  
  560.  
  561.  
  562. void glCullFace( GLenum mode )
  563. {
  564.    GET_CONTEXT;
  565.    (*CC->API.CullFace)(CC, mode);
  566. }
  567.  
  568.  
  569. void glDepthFunc( GLenum func )
  570. {
  571.    GET_CONTEXT;
  572.    (*CC->API.DepthFunc)( CC, func );
  573. }
  574.  
  575.  
  576. void glDepthMask( GLboolean flag )
  577. {
  578.    GET_CONTEXT;
  579.    (*CC->API.DepthMask)( CC, flag );
  580. }
  581.  
  582.  
  583. void glDepthRange( GLclampd near_val, GLclampd far_val )
  584. {
  585.    GET_CONTEXT;
  586.    (*CC->API.DepthRange)( CC, near_val, far_val );
  587. }
  588.  
  589.  
  590. void glDeleteLists( GLuint list, GLsizei range )
  591. {
  592.    GET_CONTEXT;
  593.    (*CC->API.DeleteLists)(CC, list, range);
  594. }
  595.  
  596.  
  597. void glDeleteTextures( GLsizei n, const GLuint *textures)
  598. {
  599.    GET_CONTEXT;
  600.    (*CC->API.DeleteTextures)(CC, n, textures);
  601. }
  602.  
  603.  
  604. void glDisable( GLenum cap )
  605. {
  606.    GET_CONTEXT;
  607.    (*CC->API.Disable)( CC, cap );
  608. }
  609.  
  610.  
  611. void glDisableClientState( GLenum cap )
  612. {
  613.    GET_CONTEXT;
  614.    (*CC->API.DisableClientState)( CC, cap );
  615. }
  616.  
  617.  
  618. void glDrawArrays( GLenum mode, GLint first, GLsizei count )
  619. {
  620.    GET_CONTEXT;
  621.    (*CC->API.DrawArrays)(CC, mode, first, count);
  622. }
  623.  
  624.  
  625. void glDrawBuffer( GLenum mode )
  626. {
  627.    GET_CONTEXT;
  628.    (*CC->API.DrawBuffer)(CC, mode);
  629. }
  630.  
  631.  
  632. void glDrawElements( GLenum mode, GLsizei count,
  633.                      GLenum type, const GLvoid *indices )
  634. {
  635.    GET_CONTEXT;
  636.    (*CC->API.DrawElements)( CC, mode, count, type, indices );
  637. }
  638.  
  639.  
  640. void glDrawPixels( GLsizei width, GLsizei height,
  641.                    GLenum format, GLenum type, const GLvoid *pixels )
  642. {
  643.    GET_CONTEXT;
  644.    (*CC->API.DrawPixels)( CC, width, height, format, type, pixels );
  645. }
  646.  
  647.  
  648. void glEnable( GLenum cap )
  649. {
  650.    GET_CONTEXT;
  651.    (*CC->API.Enable)( CC, cap );
  652. }
  653.  
  654.  
  655. void glEnableClientState( GLenum cap )
  656. {
  657.    GET_CONTEXT;
  658.    (*CC->API.EnableClientState)( CC, cap );
  659. }
  660.  
  661.  
  662. void glEnd( void )
  663. {
  664.    GET_CONTEXT;
  665.    (*CC->API.End)( CC );
  666. }
  667.  
  668.  
  669. void glEndList( void )
  670. {
  671.    GET_CONTEXT;
  672.    (*CC->API.EndList)(CC);
  673. }
  674.  
  675.  
  676.  
  677.  
  678. void glEvalCoord1d( GLdouble u )
  679. {
  680.    GET_CONTEXT;
  681.    (*CC->API.EvalCoord1f)( CC, (GLfloat) u );
  682. }
  683.  
  684.  
  685. void glEvalCoord1f( GLfloat u )
  686. {
  687.    GET_CONTEXT;
  688.    (*CC->API.EvalCoord1f)( CC, u );
  689. }
  690.  
  691.  
  692. void glEvalCoord1dv( const GLdouble *u )
  693. {
  694.    GET_CONTEXT;
  695.    (*CC->API.EvalCoord1f)( CC, (GLfloat) *u );
  696. }
  697.  
  698.  
  699. void glEvalCoord1fv( const GLfloat *u )
  700. {
  701.    GET_CONTEXT;
  702.    (*CC->API.EvalCoord1f)( CC, (GLfloat) *u );
  703. }
  704.  
  705.  
  706. void glEvalCoord2d( GLdouble u, GLdouble v )
  707. {
  708.    GET_CONTEXT;
  709.    (*CC->API.EvalCoord2f)( CC, (GLfloat) u, (GLfloat) v );
  710. }
  711.  
  712.  
  713. void glEvalCoord2f( GLfloat u, GLfloat v )
  714. {
  715.    GET_CONTEXT;
  716.    (*CC->API.EvalCoord2f)( CC, u, v );
  717. }
  718.  
  719.  
  720. void glEvalCoord2dv( const GLdouble *u )
  721. {
  722.    GET_CONTEXT;
  723.    (*CC->API.EvalCoord2f)( CC, (GLfloat) u[0], (GLfloat) u[1] );
  724. }
  725.  
  726.  
  727. void glEvalCoord2fv( const GLfloat *u )
  728. {
  729.    GET_CONTEXT;
  730.    (*CC->API.EvalCoord2f)( CC, u[0], u[1] );
  731. }
  732.  
  733.  
  734. void glEvalPoint1( GLint i )
  735. {
  736.    GET_CONTEXT;
  737.    (*CC->API.EvalPoint1)( CC, i );
  738. }
  739.  
  740.  
  741. void glEvalPoint2( GLint i, GLint j )
  742. {
  743.    GET_CONTEXT;
  744.    (*CC->API.EvalPoint2)( CC, i, j );
  745. }
  746.  
  747.  
  748. void glEvalMesh1( GLenum mode, GLint i1, GLint i2 )
  749. {
  750.    GET_CONTEXT;
  751.    (*CC->API.EvalMesh1)( CC, mode, i1, i2 );
  752. }
  753.  
  754.  
  755. void glEdgeFlag( GLboolean flag )
  756. {
  757.    GET_CONTEXT;
  758.    (*CC->API.EdgeFlag)(CC, flag);
  759. }
  760.  
  761.  
  762. void glEdgeFlagv( const GLboolean *flag )
  763. {
  764.    GET_CONTEXT;
  765.    (*CC->API.EdgeFlag)(CC, *flag);
  766. }
  767.  
  768.  
  769. void glEdgeFlagPointer( GLsizei stride, const GLboolean *ptr )
  770. {
  771.    GET_CONTEXT;
  772.    (*CC->API.EdgeFlagPointer)(CC, stride, ptr);
  773. }
  774.  
  775.  
  776. void glEvalMesh2( GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2 )
  777. {
  778.    GET_CONTEXT;
  779.    (*CC->API.EvalMesh2)( CC, mode, i1, i2, j1, j2 );
  780. }
  781.  
  782.  
  783. void glFeedbackBuffer( GLsizei size, GLenum type, GLfloat *buffer )
  784. {
  785.    GET_CONTEXT;
  786.    (*CC->API.FeedbackBuffer)(CC, size, type, buffer);
  787. }
  788.  
  789.  
  790. void glFinish( void )
  791. {
  792.    GET_CONTEXT;
  793.    (*CC->API.Finish)(CC);
  794. }
  795.  
  796.  
  797. void glFlush( void )
  798. {
  799.    GET_CONTEXT;
  800.    (*CC->API.Flush)(CC);
  801. }
  802.  
  803.  
  804. void glFogf( GLenum pname, GLfloat param )
  805. {
  806.    GET_CONTEXT;
  807.    (*CC->API.Fogfv)(CC, pname, ¶m);
  808. }
  809.  
  810.  
  811. void glFogi( GLenum pname, GLint param )
  812. {
  813.    GLfloat fparam = (GLfloat) param;
  814.    GET_CONTEXT;
  815.    (*CC->API.Fogfv)(CC, pname, &fparam);
  816. }
  817.  
  818.  
  819. void glFogfv( GLenum pname, const GLfloat *params )
  820. {
  821.    GET_CONTEXT;
  822.    (*CC->API.Fogfv)(CC, pname, params);
  823. }
  824.  
  825.  
  826. void glFogiv( GLenum pname, const GLint *params )
  827. {
  828.    GLfloat p[4];
  829.    GET_CONTEXT;
  830.  
  831.    switch (pname) {
  832.       case GL_FOG_MODE:
  833.       case GL_FOG_DENSITY:
  834.       case GL_FOG_START:
  835.       case GL_FOG_END:
  836.       case GL_FOG_INDEX:
  837.          p[0] = (GLfloat) *params;
  838.      break;
  839.       case GL_FOG_COLOR:
  840.      p[0] = INT_TO_FLOAT( params[0] );
  841.      p[1] = INT_TO_FLOAT( params[1] );
  842.      p[2] = INT_TO_FLOAT( params[2] );
  843.      p[3] = INT_TO_FLOAT( params[3] );
  844.      break;
  845.       default:
  846.          /* Error will be caught later in gl_Fogfv */
  847.          ;
  848.    }
  849.    (*CC->API.Fogfv)( CC, pname, p );
  850. }
  851.  
  852.  
  853.  
  854. void glFrontFace( GLenum mode )
  855. {
  856.    GET_CONTEXT;
  857.    (*CC->API.FrontFace)(CC, mode);
  858. }
  859.  
  860.  
  861. void glFrustum( GLdouble left, GLdouble right,
  862.                 GLdouble bottom, GLdouble top,
  863.                 GLdouble nearval, GLdouble farval )
  864. {
  865.    GLfloat x, y, a, b, c, d;
  866.    GLfloat m[16];
  867.    GET_CONTEXT;
  868.  
  869.    if (nearval<=0.0 || farval<=0.0) {
  870.       gl_error( CC, GL_INVALID_VALUE, "glFrustum(near or far)" );
  871.    }
  872.  
  873.    x = (2.0*nearval) / (right-left);
  874.    y = (2.0*nearval) / (top-bottom);
  875.    a = (right+left) / (right-left);
  876.    b = (top+bottom) / (top-bottom);
  877.    c = -(farval+nearval) / ( farval-nearval);
  878.    d = -(2.0*farval*nearval) / (farval-nearval);  /* error? */
  879.  
  880. #define M(row,col)  m[col*4+row]
  881.    M(0,0) = x;     M(0,1) = 0.0F;  M(0,2) = a;      M(0,3) = 0.0F;
  882.    M(1,0) = 0.0F;  M(1,1) = y;     M(1,2) = b;      M(1,3) = 0.0F;
  883.    M(2,0) = 0.0F;  M(2,1) = 0.0F;  M(2,2) = c;      M(2,3) = d;
  884.    M(3,0) = 0.0F;  M(3,1) = 0.0F;  M(3,2) = -1.0F;  M(3,3) = 0.0F;
  885. #undef M
  886.  
  887.    (*CC->API.MultMatrixf)( CC, m );
  888. }
  889.  
  890.  
  891. GLuint glGenLists( GLsizei range )
  892. {
  893.    GET_CONTEXT;
  894.    return (*CC->API.GenLists)(CC, range);
  895. }
  896.  
  897.  
  898. void glGenTextures( GLsizei n, GLuint *textures )
  899. {
  900.    GET_CONTEXT;
  901.    (*CC->API.GenTextures)(CC, n, textures);
  902. }
  903.  
  904.  
  905. void glGetBooleanv( GLenum pname, GLboolean *params )
  906. {
  907.    GET_CONTEXT;
  908.    (*CC->API.GetBooleanv)(CC, pname, params);
  909. }
  910.  
  911.  
  912. void glGetClipPlane( GLenum plane, GLdouble *equation )
  913. {
  914.    GET_CONTEXT;
  915.    (*CC->API.GetClipPlane)(CC, plane, equation);
  916. }
  917.  
  918.  
  919. void glGetDoublev( GLenum pname, GLdouble *params )
  920. {
  921.    GET_CONTEXT;
  922.    (*CC->API.GetDoublev)(CC, pname, params);
  923. }
  924.  
  925.  
  926. GLenum glGetError( void )
  927. {
  928.    GET_CONTEXT;
  929.    if (!CC) {
  930.       /* No current context */
  931.       return GL_NO_ERROR;
  932.    }
  933.    return (*CC->API.GetError)(CC);
  934. }
  935.  
  936.  
  937. void glGetFloatv( GLenum pname, GLfloat *params )
  938. {
  939.    GET_CONTEXT;
  940.    (*CC->API.GetFloatv)(CC, pname, params);
  941. }
  942.  
  943.  
  944. void glGetIntegerv( GLenum pname, GLint *params )
  945. {
  946.    GET_CONTEXT;
  947.    (*CC->API.GetIntegerv)(CC, pname, params);
  948. }
  949.  
  950.  
  951. void glGetLightfv( GLenum light, GLenum pname, GLfloat *params )
  952. {
  953.    GET_CONTEXT;
  954.    (*CC->API.GetLightfv)(CC, light, pname, params);
  955. }
  956.  
  957.  
  958. void glGetLightiv( GLenum light, GLenum pname, GLint *params )
  959. {
  960.    GET_CONTEXT;
  961.    (*CC->API.GetLightiv)(CC, light, pname, params);
  962. }
  963.  
  964.  
  965. void glGetMapdv( GLenum target, GLenum query, GLdouble *v )
  966. {
  967.    GET_CONTEXT;
  968.    (*CC->API.GetMapdv)( CC, target, query, v );
  969. }
  970.  
  971.  
  972. void glGetMapfv( GLenum target, GLenum query, GLfloat *v )
  973. {
  974.    GET_CONTEXT;
  975.    (*CC->API.GetMapfv)( CC, target, query, v );
  976. }
  977.  
  978.  
  979. void glGetMapiv( GLenum target, GLenum query, GLint *v )
  980. {
  981.    GET_CONTEXT;
  982.    (*CC->API.GetMapiv)( CC, target, query, v );
  983. }
  984.  
  985.  
  986. void glGetMaterialfv( GLenum face, GLenum pname, GLfloat *params )
  987. {
  988.    GET_CONTEXT;
  989.    (*CC->API.GetMaterialfv)(CC, face, pname, params);
  990. }
  991.  
  992.  
  993. void glGetMaterialiv( GLenum face, GLenum pname, GLint *params )
  994. {
  995.    GET_CONTEXT;
  996.    (*CC->API.GetMaterialiv)(CC, face, pname, params);
  997. }
  998.  
  999.  
  1000. void glGetPixelMapfv( GLenum map, GLfloat *values )
  1001. {
  1002.    GET_CONTEXT;
  1003.    (*CC->API.GetPixelMapfv)(CC, map, values);
  1004. }
  1005.  
  1006.  
  1007. void glGetPixelMapuiv( GLenum map, GLuint *values )
  1008. {
  1009.    GET_CONTEXT;
  1010.    (*CC->API.GetPixelMapuiv)(CC, map, values);
  1011. }
  1012.  
  1013.  
  1014. void glGetPixelMapusv( GLenum map, GLushort *values )
  1015. {
  1016.    GET_CONTEXT;
  1017.    (*CC->API.GetPixelMapusv)(CC, map, values);
  1018. }
  1019.  
  1020.  
  1021. void glGetPointerv( GLenum pname, GLvoid **params )
  1022. {
  1023.    GET_CONTEXT;
  1024.    (*CC->API.GetPointerv)(CC, pname, params);
  1025. }
  1026.  
  1027.  
  1028. void glGetPolygonStipple( GLubyte *mask )
  1029. {
  1030.    GET_CONTEXT;
  1031.    (*CC->API.GetPolygonStipple)(CC, mask);
  1032. }
  1033.  
  1034.  
  1035. const GLubyte *glGetString( GLenum name )
  1036. {
  1037.    GET_CONTEXT;
  1038.    return (*CC->API.GetString)(CC, name);
  1039. }
  1040.  
  1041.  
  1042.  
  1043. void glGetTexEnvfv( GLenum target, GLenum pname, GLfloat *params )
  1044. {
  1045.    GET_CONTEXT;
  1046.    (*CC->API.GetTexEnvfv)(CC, target, pname, params);
  1047. }
  1048.  
  1049.  
  1050. void glGetTexEnviv( GLenum target, GLenum pname, GLint *params )
  1051. {
  1052.    GET_CONTEXT;
  1053.    (*CC->API.GetTexEnviv)(CC, target, pname, params);
  1054. }
  1055.  
  1056.  
  1057. void glGetTexGeniv( GLenum coord, GLenum pname, GLint *params )
  1058. {
  1059.    GET_CONTEXT;
  1060.    (*CC->API.GetTexGeniv)(CC, coord, pname, params);
  1061. }
  1062.  
  1063.  
  1064. void glGetTexGendv( GLenum coord, GLenum pname, GLdouble *params )
  1065. {
  1066.    GET_CONTEXT;
  1067.    (*CC->API.GetTexGendv)(CC, coord, pname, params);
  1068. }
  1069.  
  1070.  
  1071. void glGetTexGenfv( GLenum coord, GLenum pname, GLfloat *params )
  1072. {
  1073.    GET_CONTEXT;
  1074.    (*CC->API.GetTexGenfv)(CC, coord, pname, params);
  1075. }
  1076.  
  1077.  
  1078.  
  1079. void glGetTexImage( GLenum target, GLint level, GLenum format,
  1080.                   GLenum type, GLvoid *pixels )
  1081. {
  1082.    GET_CONTEXT;
  1083.    (*CC->API.GetTexImage)(CC, target, level, format, type, pixels);
  1084. }
  1085.  
  1086.  
  1087. void glGetTexLevelParameterfv( GLenum target, GLint level,
  1088.                                GLenum pname, GLfloat *params )
  1089. {
  1090.    GET_CONTEXT;
  1091.    (*CC->API.GetTexLevelParameterfv)(CC, target, level, pname, params);
  1092. }
  1093.  
  1094.  
  1095. void glGetTexLevelParameteriv( GLenum target, GLint level,
  1096.                                GLenum pname, GLint *params )
  1097. {
  1098.    GET_CONTEXT;
  1099.    (*CC->API.GetTexLevelParameteriv)(CC, target, level, pname, params);
  1100. }
  1101.  
  1102.  
  1103.  
  1104.  
  1105. void glGetTexParameterfv( GLenum target, GLenum pname, GLfloat *params)
  1106. {
  1107.    GET_CONTEXT;
  1108.    (*CC->API.GetTexParameterfv)(CC, target, pname, params);
  1109. }
  1110.  
  1111.  
  1112. void glGetTexParameteriv( GLenum target, GLenum pname, GLint *params )
  1113. {
  1114.    GET_CONTEXT;
  1115.    (*CC->API.GetTexParameteriv)(CC, target, pname, params);
  1116. }
  1117.  
  1118.  
  1119. void glHint( GLenum target, GLenum mode )
  1120. {
  1121.    GET_CONTEXT;
  1122.    (*CC->API.Hint)(CC, target, mode);
  1123. }
  1124.  
  1125.  
  1126. void glIndexd( GLdouble c )
  1127. {
  1128.    GET_CONTEXT;
  1129.    (*CC->API.Indexf)( CC, (GLfloat) c );
  1130. }
  1131.  
  1132.  
  1133. void glIndexf( GLfloat c )
  1134. {
  1135.    GET_CONTEXT;
  1136.    (*CC->API.Indexf)( CC, c );
  1137. }
  1138.  
  1139.  
  1140. void glIndexi( GLint c )
  1141. {
  1142.    GET_CONTEXT;
  1143.    (*CC->API.Indexi)( CC, c );
  1144. }
  1145.  
  1146.  
  1147. void glIndexs( GLshort c )
  1148. {
  1149.    GET_CONTEXT;
  1150.    (*CC->API.Indexi)( CC, (GLint) c );
  1151. }
  1152.  
  1153.  
  1154. #ifdef GL_VERSION_1_1
  1155. void glIndexub( GLubyte c )
  1156. {
  1157.    GET_CONTEXT;
  1158.    (*CC->API.Indexi)( CC, (GLint) c );
  1159. }
  1160. #endif
  1161.  
  1162.  
  1163. void glIndexdv( const GLdouble *c )
  1164. {
  1165.    GET_CONTEXT;
  1166.    (*CC->API.Indexf)( CC, (GLfloat) *c );
  1167. }
  1168.  
  1169.  
  1170. void glIndexfv( const GLfloat *c )
  1171. {
  1172.    GET_CONTEXT;
  1173.    (*CC->API.Indexf)( CC, *c );
  1174. }
  1175.  
  1176.  
  1177. void glIndexiv( const GLint *c )
  1178. {
  1179.    GET_CONTEXT;
  1180.    (*CC->API.Indexi)( CC, *c );
  1181. }
  1182.  
  1183.  
  1184. void glIndexsv( const GLshort *c )
  1185. {
  1186.    GET_CONTEXT;
  1187.    (*CC->API.Indexi)( CC, (GLint) *c );
  1188. }
  1189.  
  1190.  
  1191. #ifdef GL_VERSION_1_1
  1192. void glIndexubv( const GLubyte *c )
  1193. {
  1194.    GET_CONTEXT;
  1195.    (*CC->API.Indexi)( CC, (GLint) *c );
  1196. }
  1197. #endif
  1198.  
  1199.  
  1200. void glIndexMask( GLuint mask )
  1201. {
  1202.    GET_CONTEXT;
  1203.    (*CC->API.IndexMask)(CC, mask);
  1204. }
  1205.  
  1206.  
  1207. void glIndexPointer( GLenum type, GLsizei stride, const GLvoid *ptr )
  1208. {
  1209.    GET_CONTEXT;
  1210.    (*CC->API.IndexPointer)(CC, type, stride, ptr);
  1211. }
  1212.  
  1213.  
  1214. void glInterleavedArrays( GLenum format, GLsizei stride,
  1215.                           const GLvoid *pointer )
  1216. {
  1217.    GET_CONTEXT;
  1218.    (*CC->API.InterleavedArrays)( CC, format, stride, pointer );
  1219. }
  1220.  
  1221.  
  1222. void glInitNames( void )
  1223. {
  1224.    GET_CONTEXT;
  1225.    (*CC->API.InitNames)(CC);
  1226. }
  1227.  
  1228.  
  1229. GLboolean glIsList( GLuint list )
  1230. {
  1231.    GET_CONTEXT;
  1232.    return (*CC->API.IsList)(CC, list);
  1233. }
  1234.  
  1235.  
  1236. GLboolean glIsTexture( GLuint texture )
  1237. {
  1238.    GET_CONTEXT;
  1239.    return (*CC->API.IsTexture)(CC, texture);
  1240. }
  1241.  
  1242.  
  1243. void glLightf( GLenum light, GLenum pname, GLfloat param )
  1244. {
  1245.    GET_CONTEXT;
  1246.    (*CC->API.Lightfv)( CC, light, pname, ¶m, 1 );
  1247. }
  1248.  
  1249.  
  1250.  
  1251. void glLighti( GLenum light, GLenum pname, GLint param )
  1252. {
  1253.    GLfloat fparam = (GLfloat) param;
  1254.    GET_CONTEXT;
  1255.    (*CC->API.Lightfv)( CC, light, pname, &fparam, 1 );
  1256. }
  1257.  
  1258.  
  1259.  
  1260. void glLightfv( GLenum light, GLenum pname, const GLfloat *params )
  1261. {
  1262.    GET_CONTEXT;
  1263.    (*CC->API.Lightfv)( CC, light, pname, params, 4 );
  1264. }
  1265.  
  1266.  
  1267.  
  1268. void glLightiv( GLenum light, GLenum pname, const GLint *params )
  1269. {
  1270.    GLfloat fparam[4];
  1271.    GET_CONTEXT;
  1272.  
  1273.    switch (pname) {
  1274.       case GL_AMBIENT:
  1275.       case GL_DIFFUSE:
  1276.       case GL_SPECULAR:
  1277.          fparam[0] = INT_TO_FLOAT( params[0] );
  1278.          fparam[1] = INT_TO_FLOAT( params[1] );
  1279.          fparam[2] = INT_TO_FLOAT( params[2] );
  1280.          fparam[3] = INT_TO_FLOAT( params[3] );
  1281.          break;
  1282.       case GL_POSITION:
  1283.          fparam[0] = (GLfloat) params[0];
  1284.          fparam[1] = (GLfloat) params[1];
  1285.          fparam[2] = (GLfloat) params[2];
  1286.          fparam[3] = (GLfloat) params[3];
  1287.          break;
  1288.       case GL_SPOT_DIRECTION:
  1289.          fparam[0] = (GLfloat) params[0];
  1290.          fparam[1] = (GLfloat) params[1];
  1291.          fparam[2] = (GLfloat) params[2];
  1292.          break;
  1293.       case GL_SPOT_EXPONENT:
  1294.       case GL_SPOT_CUTOFF:
  1295.       case GL_CONSTANT_ATTENUATION:
  1296.       case GL_LINEAR_ATTENUATION:
  1297.       case GL_QUADRATIC_ATTENUATION:
  1298.          fparam[0] = (GLfloat) params[0];
  1299.          break;
  1300.       default:
  1301.          /* error will be caught later in gl_Lightfv */
  1302.          ;
  1303.    }
  1304.    (*CC->API.Lightfv)( CC, light, pname, fparam, 4 );
  1305. }
  1306.  
  1307.  
  1308.  
  1309. void glLightModelf( GLenum pname, GLfloat param )
  1310. {
  1311.    GET_CONTEXT;
  1312.    (*CC->API.LightModelfv)( CC, pname, ¶m );
  1313. }
  1314.  
  1315.  
  1316. void glLightModeli( GLenum pname, GLint param )
  1317. {
  1318.    GLfloat fparam[4];
  1319.    GET_CONTEXT;
  1320.    fparam[0] = (GLfloat) param;
  1321.    (*CC->API.LightModelfv)( CC, pname, fparam );
  1322. }
  1323.  
  1324.  
  1325. void glLightModelfv( GLenum pname, const GLfloat *params )
  1326. {
  1327.    GET_CONTEXT;
  1328.    (*CC->API.LightModelfv)( CC, pname, params );
  1329. }
  1330.  
  1331.  
  1332. void glLightModeliv( GLenum pname, const GLint *params )
  1333. {
  1334.    GLfloat fparam[4];
  1335.    GET_CONTEXT;
  1336.  
  1337.    switch (pname) {
  1338.       case GL_LIGHT_MODEL_AMBIENT:
  1339.          fparam[0] = INT_TO_FLOAT( params[0] );
  1340.          fparam[1] = INT_TO_FLOAT( params[1] );
  1341.          fparam[2] = INT_TO_FLOAT( params[2] );
  1342.          fparam[3] = INT_TO_FLOAT( params[3] );
  1343.          break;
  1344.       case GL_LIGHT_MODEL_LOCAL_VIEWER:
  1345.       case GL_LIGHT_MODEL_TWO_SIDE:
  1346.          fparam[0] = (GLfloat) params[0];
  1347.          break;
  1348.       default:
  1349.          /* Error will be caught later in gl_LightModelfv */
  1350.          ;
  1351.    }
  1352.    (*CC->API.LightModelfv)( CC, pname, fparam );
  1353. }
  1354.  
  1355.  
  1356. void glLineWidth( GLfloat width )
  1357. {
  1358.    GET_CONTEXT;
  1359.    (*CC->API.LineWidth)(CC, width);
  1360. }
  1361.  
  1362.  
  1363. void glLineStipple( GLint factor, GLushort pattern )
  1364. {
  1365.    GET_CONTEXT;
  1366.    (*CC->API.LineStipple)(CC, factor, pattern);
  1367. }
  1368.  
  1369.  
  1370. void glListBase( GLuint base )
  1371. {
  1372.    GET_CONTEXT;
  1373.    (*CC->API.ListBase)(CC, base);
  1374. }
  1375.  
  1376.  
  1377. void glLoadIdentity( void )
  1378. {
  1379.    static GLfloat identity[16] = {
  1380.       1.0, 0.0, 0.0, 0.0,
  1381.       0.0, 1.0, 0.0, 0.0,
  1382.       0.0, 0.0, 1.0, 0.0,
  1383.       0.0, 0.0, 0.0, 1.0
  1384.    };
  1385.    GET_CONTEXT;
  1386.    (*CC->API.LoadMatrixf)( CC, identity );
  1387. }
  1388.  
  1389.  
  1390. void glLoadMatrixd( const GLdouble *m )
  1391. {
  1392.    GLfloat fm[16];
  1393.    GLuint i;
  1394.    GET_CONTEXT;
  1395.  
  1396.    for (i=0;i<16;i++) {
  1397.       fm[i] = (GLfloat) m[i];
  1398.    }
  1399.  
  1400.    (*CC->API.LoadMatrixf)( CC, fm );
  1401. }
  1402.  
  1403.  
  1404. void glLoadMatrixf( const GLfloat *m )
  1405. {
  1406.    GET_CONTEXT;
  1407.    (*CC->API.LoadMatrixf)( CC, m );
  1408. }
  1409.  
  1410.  
  1411. void glLoadName( GLuint name )
  1412. {
  1413.    GET_CONTEXT;
  1414.    (*CC->API.LoadName)(CC, name);
  1415. }
  1416.  
  1417.  
  1418. void glLogicOp( GLenum opcode )
  1419. {
  1420.    GET_CONTEXT;
  1421.    (*CC->API.LogicOp)(CC, opcode);
  1422. }
  1423.  
  1424.  
  1425.  
  1426. void glMap1d( GLenum target, GLdouble u1, GLdouble u2, GLint stride,
  1427.               GLint order, const GLdouble *points )
  1428. {
  1429.    GLfloat *pnts;
  1430.    GLboolean retain;
  1431.    GET_CONTEXT;
  1432.  
  1433.    pnts = gl_copy_map_points1d( target, stride, order, points );
  1434.    retain = CC->CompileFlag;
  1435.    (*CC->API.Map1f)( CC, target, u1, u2, stride, order, pnts, retain );
  1436. }
  1437.  
  1438.  
  1439. void glMap1f( GLenum target, GLfloat u1, GLfloat u2, GLint stride,
  1440.               GLint order, const GLfloat *points )
  1441. {
  1442.    GLfloat *pnts;
  1443.    GLboolean retain;
  1444.    GET_CONTEXT;
  1445.  
  1446.    pnts = gl_copy_map_points1f( target, stride, order, points );
  1447.    retain = CC->CompileFlag;
  1448.    (*CC->API.Map1f)( CC, target, u1, u2, stride, order, pnts, retain );
  1449. }
  1450.  
  1451.  
  1452. void glMap2d( GLenum target,
  1453.               GLdouble u1, GLdouble u2, GLint ustride, GLint uorder,
  1454.               GLdouble v1, GLdouble v2, GLint vstride, GLint vorder,
  1455.               const GLdouble *points )
  1456. {
  1457.    GLfloat *pnts;
  1458.    GLboolean retain;
  1459.    GET_CONTEXT;
  1460.  
  1461.    pnts = gl_copy_map_points2d( target, ustride, uorder,
  1462.                                 vstride, vorder, points );
  1463.    retain = CC->CompileFlag;
  1464.    (*CC->API.Map2f)( CC, target, u1, u2, ustride, uorder,
  1465.                      v1, v2, vstride, vorder, pnts, retain );
  1466. }
  1467.  
  1468.  
  1469. void glMap2f( GLenum target,
  1470.               GLfloat u1, GLfloat u2, GLint ustride, GLint uorder,
  1471.               GLfloat v1, GLfloat v2, GLint vstride, GLint vorder,
  1472.               const GLfloat *points )
  1473. {
  1474.    GLfloat *pnts;
  1475.    GLboolean retain;
  1476.    GET_CONTEXT;
  1477.  
  1478.    pnts = gl_copy_map_points2f( target, ustride, uorder,
  1479.                                 vstride, vorder, points );
  1480.    retain = CC->CompileFlag;
  1481.    (*CC->API.Map2f)( CC, target, u1, u2, ustride, uorder,
  1482.                      v1, v2, vstride, vorder, pnts, retain );
  1483. }
  1484.  
  1485.  
  1486. void glMapGrid1d( GLint un, GLdouble u1, GLdouble u2 )
  1487. {
  1488.    GET_CONTEXT;
  1489.    (*CC->API.MapGrid1f)( CC, un, (GLfloat) u1, (GLfloat) u2 );
  1490. }
  1491.  
  1492.  
  1493. void glMapGrid1f( GLint un, GLfloat u1, GLfloat u2 )
  1494. {
  1495.    GET_CONTEXT;
  1496.    (*CC->API.MapGrid1f)( CC, un, u1, u2 );
  1497. }
  1498.  
  1499.  
  1500. void glMapGrid2d( GLint un, GLdouble u1, GLdouble u2,
  1501.           GLint vn, GLdouble v1, GLdouble v2 )
  1502. {
  1503.    GET_CONTEXT;
  1504.    (*CC->API.MapGrid2f)( CC, un, (GLfloat) u1, (GLfloat) u2,
  1505.                                   vn, (GLfloat) v1, (GLfloat) v2 );
  1506. }
  1507.  
  1508.  
  1509. void glMapGrid2f( GLint un, GLfloat u1, GLfloat u2,
  1510.           GLint vn, GLfloat v1, GLfloat v2 )
  1511. {
  1512.    GET_CONTEXT;
  1513.    (*CC->API.MapGrid2f)( CC, un, u1, u2, vn, v1, v2 );
  1514. }
  1515.  
  1516.  
  1517. void glMaterialf( GLenum face, GLenum pname, GLfloat param )
  1518. {
  1519.    GET_CONTEXT;
  1520.    (*CC->API.Materialfv)( CC, face, pname, ¶m );
  1521. }
  1522.  
  1523.  
  1524.  
  1525. void glMateriali( GLenum face, GLenum pname, GLint param )
  1526. {
  1527.    GLfloat fparam[4];
  1528.    GET_CONTEXT;
  1529.    fparam[0] = (GLfloat) param;
  1530.    (*CC->API.Materialfv)( CC, face, pname, fparam );
  1531. }
  1532.  
  1533.  
  1534. void glMaterialfv( GLenum face, GLenum pname, const GLfloat *params )
  1535. {
  1536.    GET_CONTEXT;
  1537.    (*CC->API.Materialfv)( CC, face, pname, params );
  1538. }
  1539.  
  1540.  
  1541. void glMaterialiv( GLenum face, GLenum pname, const GLint *params )
  1542. {
  1543.    GLfloat fparam[4];
  1544.    GET_CONTEXT;
  1545.    switch (pname) {
  1546.       case GL_AMBIENT:
  1547.       case GL_DIFFUSE:
  1548.       case GL_SPECULAR:
  1549.       case GL_EMISSION:
  1550.       case GL_AMBIENT_AND_DIFFUSE:
  1551.          fparam[0] = INT_TO_FLOAT( params[0] );
  1552.          fparam[1] = INT_TO_FLOAT( params[1] );
  1553.          fparam[2] = INT_TO_FLOAT( params[2] );
  1554.          fparam[3] = INT_TO_FLOAT( params[3] );
  1555.          break;
  1556.       case GL_SHININESS:
  1557.          fparam[0] = (GLfloat) params[0];
  1558.          break;
  1559.       case GL_COLOR_INDEXES:
  1560.          fparam[0] = (GLfloat) params[0];
  1561.          fparam[1] = (GLfloat) params[1];
  1562.          fparam[2] = (GLfloat) params[2];
  1563.          break;
  1564.       default:
  1565.          /* Error will be caught later in gl_Materialfv */
  1566.          ;
  1567.    }
  1568.    (*CC->API.Materialfv)( CC, face, pname, fparam );
  1569. }
  1570.  
  1571.  
  1572. void glMatrixMode( GLenum mode )
  1573. {
  1574.    GET_CONTEXT;
  1575.    (*CC->API.MatrixMode)( CC, mode );
  1576. }
  1577.  
  1578.  
  1579. void glMultMatrixd( const GLdouble *m )
  1580. {
  1581.    GLfloat fm[16];
  1582.    GLuint i;
  1583.    GET_CONTEXT;
  1584.  
  1585.    for (i=0;i<16;i++) {
  1586.       fm[i] = (GLfloat) m[i];
  1587.    }
  1588.  
  1589.    (*CC->API.MultMatrixf)( CC, fm );
  1590. }
  1591.  
  1592.  
  1593. void glMultMatrixf( const GLfloat *m )
  1594. {
  1595.    GET_CONTEXT;
  1596.    (*CC->API.MultMatrixf)( CC, m );
  1597. }
  1598.  
  1599.